package com.example.designpatterns.strategy.sorting;

import com.example.designpatterns.strategy.Strategy;
import java.util.Arrays;

/**
 * 堆排序策略 - 使用堆排序算法实现排序
 * 时间复杂度：O(n log n)
 * 空间复杂度：O(1)
 * 稳定性：不稳定
 */
public class HeapSortStrategy implements Strategy<int[], int[]> {
    
    @Override
    public int[] execute(int[] input) {
        if (input == null || input.length <= 1) {
            return input;
        }
        
        // 创建数组副本，不修改原始数据
        int[] array = Arrays.copyOf(input, input.length);
        int n = array.length;
        
        // 堆排序实现
        
        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(array, n, i);
        }
        
        // 一个个从堆顶取出元素
        for (int i = n - 1; i > 0; i--) {
            // 将当前堆顶（最大值）与末尾元素交换
            int temp = array[0];
            array[0] = array[i];
            array[i] = temp;
            
            // 重新调整堆结构
            heapify(array, i, 0);
        }
        
        return array;
    }
    
    /**
     * 调整堆结构，使其满足最大堆性质
     * @param array 数组
     * @param n 堆大小
     * @param i 要调整的节点索引
     */
    private void heapify(int[] array, int n, int i) {
        int largest = i; // 初始化最大值为根节点
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点
        
        // 如果左子节点存在且大于根节点
        if (left < n && array[left] > array[largest]) {
            largest = left;
        }
        
        // 如果右子节点存在且大于当前最大值
        if (right < n && array[right] > array[largest]) {
            largest = right;
        }
        
        // 如果最大值不是根节点，则交换并继续调整
        if (largest != i) {
            int swap = array[i];
            array[i] = array[largest];
            array[largest] = swap;
            
            // 递归调整受影响的子树
            heapify(array, n, largest);
        }
    }
} 